package com.aynu.linkedList;

public class DoubleLinkedListTest {
	public static void main(String[] args) {
		DoubleLinkedList doubleLinkedList = new DoubleLinkedList();
		HerNode2 herNode1 = new HerNode2(1, "宋江", "及时雨");
		HerNode2 herNode2 = new HerNode2(2, "卢俊义", "玉麒麟");
		HerNode2 herNode3 = new HerNode2(3, "吴用", "智多星");
		HerNode2 herNode4 = new HerNode2(4, "林冲", "豹子头");

		// 添加
		doubleLinkedList.addByOrder(herNode3);
		doubleLinkedList.addByOrder(herNode1);
		doubleLinkedList.addByOrder(herNode2);
		doubleLinkedList.addByOrder(herNode2);
		doubleLinkedList.addByOrder(herNode4);

		// 修改
//		doubleLinkedList.update(new HerNode2(1, "卧槽", "哈哈"));

		// 删除
//		doubleLinkedList.delete(1);

		doubleLinkedList.list();
	}
}

class DoubleLinkedList {
	// 首先初始化一个头节点，不存放具体数据
	private HerNode2 head = new HerNode2(0, "", "");

	// 返回头节点
	public HerNode2 getHead() {
		return head;
	}

	// 添加节点,到双向链表的最后
	public void add(HerNode2 herNode) {
		// 因为head节点不能动，因此我们需要一个辅助遍历节点-temp
		HerNode2 temp = head;
		while (true) {
			// 找到链表的最后
			if (temp.next == null) {
				break;
			}
			// 如果没有找到，就将链表后移
			temp = temp.next;
		}
		// 当退出while循环时，temp指向最后的节点
		temp.next = herNode;
		herNode.pre = temp;
	}

	// 双向链表的顺序添加
	public void addByOrder(HerNode2 herNode) {
//		// 因为头节点不能动，所以需要一个辅助变量，来完成遍历
//		HerNode2 temp = head;
//		// 标志位，是否存在排名的节点？插入失败 ：插入成功
//		boolean flag = false;
//		while (true) {
//			// 遍历到链表的结尾，退出循环
//			if (temp.next == null) {
//				break;
//			}
//			// 位置找到，就在temp前面插入
//			if (temp.no > herNode.no) {
//				break;
//			} else if (temp.no == herNode.no) {// 说明需要添加的节点的排名已存在
//				flag = true;
//				break;
//			}
//			temp = temp.next;
//		}
//		// 判断flag的值
//		if (flag) {// 不能添加，说明编号以存在
//			System.out.printf("添加的英雄的节点 %d 已存在，不能加入\n", herNode.no);
//		} else {
//			// 添加到链表中
//			// 建立与temp前节点的连接
//			if (temp != head) {
////				if (temp.next != null) {
////					herNode.next = temp;
////					temp.pre = herNode;
////					herNode.pre = temp.pre;
////					temp.pre.next = herNode;
////				} else {
////					temp.next = herNode;
////					herNode.pre = temp;
////				}
//				herNode.next = temp;
//				herNode.pre = temp.pre;
//
//				temp.pre = herNode;
//				temp.pre.next = herNode;
//			} else {
//				temp.next = herNode;
//				herNode.pre = temp;
//			}
//		}
		// 因为头节点不能动，所以需要一个辅助变量，来完成遍历
		HerNode2 temp = head;

		boolean flag1 = false;
		boolean flag2 = false;
		while (true){
			if (temp.getNext() == null){
				break;
			}
			if (temp.getNext().getNo() == herNode.getNo()){
				flag1 = true;
				break;
			}else if (temp.getNext().getNo() > herNode.getNo()){
				flag2 = true;
				break;
			}
			temp = temp.getNext();
		}
		if (flag1){
			System.out.println("链表中已经存在此节点！！！");
		}else if (flag2){
			herNode.setNext(temp.getNext());
			temp.getNext().setPre(herNode);
			herNode.setPre(temp);
			temp.setNext(herNode);
		}else {
			temp.setNext(herNode);
			herNode.setPre(temp);
		}
		// 当退出while循环时，temp就指向了链表的最后
		// 形成一个双向链表
		temp.next = herNode;
		herNode.pre = temp;

	}

	// 修改双向链表，双向链表的修改和单向链表一样
	public void update(HerNode2 newHerNode) {
		// 判断是否为空
		if (head.next == null) {
			System.out.println("链表为空");
			return;
		}
		// 定义一个辅助变量
		HerNode2 temp = head.next;
		boolean flag = false;// 表示是否找到节点
		while (temp != null) {
			// 找到需要修改的节点
			if (temp.no == newHerNode.no) {
				flag = true;
				break;
			}
			// 遍历
			temp = temp.next;
		}

		// 根据flag，判断是否找到修改的节点
		if (flag) {
			temp.name = newHerNode.name;
			temp.nickName = newHerNode.nickName;
		} else {// 没有找到
			System.out.printf("没有找到编号 %d 的节点，不能修改\n", newHerNode.no);
		}
	}

	// 双向链表，删除节点
	// 1. 对于双向链表，可以直接找到删除节点，而不需要借助前后节点
	public void delete(int no) {
		// 判断链表是否为空
		if (head.next == null) {
			System.out.println("链表为空");
			return;
		}

		HerNode2 temp = head;// 创建一个辅助变量
		boolean flag = false;// 标志位，是否找到待删除节点
		while (temp != null) {// 找到最后的节点
			if (temp.no == no) {
				// 找到待删除节点
				flag = true;
				break;
			}
			temp = temp.next;
		}
		// 判断flag
		if (flag) {// 存在
			temp.pre.next = temp.next;
			if (temp.next != null) {// 如果是最后一个节点，下面就不需要执行了，要不然就会发生空指针异常
				temp.next.pre = temp.pre;
			}
		} else {
			System.out.printf("没有找到节点 %d ，因为该节点不存在\n", no);
		}
	}

	// 遍历链表
	public void list() {
		HerNode2 temp = head.next;

		if (temp == null) {
			System.out.println("链表为空");
			return;
		}

		while (temp != null) {
			// 输出节点信息
			System.out.println(temp);
			// temp，往后移
			temp = temp.next;
		}
	}
}

//双向链表
class HerNode2 {
	public int no; // 英雄编号
	public String name; // 英雄名称
	public String nickName; // 昵称
	public HerNode2 next; // 指向下一个节点
	public HerNode2 pre;// 指向上一个节点

	public HerNode2() {

	}

	public HerNode2(int hNo, String hName, String nickName) {
		this.no = hNo;
		this.name = hName;
		this.nickName = nickName;
	}

	public int getNo() {
		return no;
	}

	public void setNo(int no) {
		this.no = no;
	}

	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}

	public String getNickName() {
		return nickName;
	}

	public void setNickName(String nickName) {
		this.nickName = nickName;
	}

	public HerNode2 getNext() {
		return next;
	}

	public void setNext(HerNode2 next) {
		this.next = next;
	}

	public HerNode2 getPre() {
		return pre;
	}

	public void setPre(HerNode2 pre) {
		this.pre = pre;
	}

	@Override
	public String toString() {
		return "HerNode2 [no=" + no + ", name=" + name + ", nickName=" + nickName + "]";
	}
}